/*TSON完全基于JSON，TSON拥有更多的功能*/
@导入Java("org.json.*")
@指代类("org.json.JSONObject")
类 TSON对象
	@运算符重载
	方法 =(TSON文本 : 文本)
		@code
		try {
			return new JSONObject(#TSON文本);
		} catch (Exception e) {
			throw new RuntimeException(JSON_INIT_ERROR);
		}
		@end
	结束 方法

	/*
	获取TSON对象中指定键所对应的对象值，如：
	{
		"data" : "abc"
		"data2" : 123
	}
	其中的data键所对应的数据就是一个文本值，其是一个对象值，因为对象是所有类型的基础类
	data2键所对应的数据就是一个整数值，其也是一个对象值
	*/
	@运算符重载
	方法 [](键名 : 文本) : 对象
		返回 取对象(键名)
	结束 方法

	/*
	向TSON对象中置入新的值，可以为TSON对象，TSON数组，文本值，整数值等，如：
	{
		"data" : 3.14
	}
	这个TSON对象中只有一个数据，调用 置入("name","A")后，其将会变为：
	{
		"data" : 3.14,
		"name" : "A"
	}
	*/
	@运算符重载
	方法 []=(键名 : 文本, 值 : 对象)
		@code
		try {
			#this.put(#键名, #值);
		} catch (JSONException e) {
			e.printStackTrace();
		}
		@end
	结束 方法

	/*
	判断TSON对象中是否存在指定键名
	*/
	@运算符重载
	方法 ?(键名 : 文本) : 逻辑型
		@code
		return #this.has(#键名);
		@end
	结束 方法

	/*
	获取TSON对象中指定键所对应的子TSON对象，如：
	{
		"data" : {
			"name": "abc"
		}
	}
	其中的data键所对应的数据就是一个TSON对象
	*/
	方法 取TSON对象(键名 : 文本) : TSON对象
		@code
		try {
			return #this.getJSONObject(#键名);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
		@end
	结束 方法

	/*
	获取TSON对象中指定键所对应的TSON数组，如：
	{
		"data" : [1,2,3]
	}
	其中的data键所对应的数据就是一个TSON数组
	*/
	方法 取TSON数组(键名 : 文本) : TSON数组
		@code
		try {
			return #this.getJSONArray(#键名);
		} catch (JSONException e) {
			return null;
		}
		@end
	结束 方法

	/*
	获取TSON对象中指定键所对应的对象值，如：
	{
		"data" : "abc"
		"data2" : 123
	}
	其中的data键所对应的数据就是一个文本值，其是一个对象值，因为对象是所有类型的基础类
	data2键所对应的数据就是一个整数值，其也是一个对象值
	*/
	方法 取对象(键名 : 文本) : 对象
		@code
		try {
			return #this.get(#键名);
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return null;
		@end
	结束 方法

	/*
	获取TSON对象中指定键所对应的文本值，如：
	{
		"data" : "abc"
	}
	其中的data键所对应的数据就是一个文本值
	*/
	方法 取文本(键名 : 文本) : 文本
		@code
		try {
			return #this.getString(#键名);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		@end
	结束 方法

	/*
	获取TSON对象中指定键所对应的整数值，如：
	{
		"data" : 123
	}
	其中的data键所对应的数据就是一个整数值
	*/
	方法 取整数(键名 : 文本, 默认值 : 整数 = 0) : 整数
		@code
		try {
			return #this.getInt(#键名);
		} catch (Exception e) {
			e.printStackTrace();
			return #默认值;
		}
		@end
	结束 方法

	/*
	获取TSON对象中指定键所对应的长整数值，如：
	{
		"data" : 12369855665555L
	}
	其中的data键所对应的数据就是一个长整数值
	*/
	方法 取长整数(键名 : 文本, 默认值 : 整数 = 0) : 长整数
		@code
		try {
			return #this.getLong(#键名);
		} catch (Exception e) {
			e.printStackTrace();
			return #默认值;
		}
		@end
	结束 方法

	/*
	获取TSON对象中指定键所对应的小数值，如：
	{
		"data" : 3.14
	}
	其中的data键所对应的数据就是一个小数值
	*/
	方法 取小数(键名 : 文本, 默认值 : 小数 = 0.0) : 小数
		@code
		try {
			return #this.getDouble(#键名);
		} catch (Exception e) {
			e.printStackTrace();
			return #默认值;
		}
		@end
	结束 方法

	/*
	获取TSON对象中指定键所对应的逻辑值，如：
	{
		"data" : true
	}
	其中的data键所对应的数据就是一个逻辑值
	*/
	方法 取逻辑值(键名 : 文本, 默认值 : 逻辑型 = 假) : 逻辑型
		@code
		try {
			return #this.getBoolean(#键名);
		} catch (Exception e) {
			e.printStackTrace();
			return #默认值;
		}
		@end
	结束 方法

	/*
	向TSON对象中置入新的值，可以为TSON对象，TSON数组，文本值，整数值等，如：
	{
		"data" : 3.14
	}
	这个TSON对象中只有一个数据，调用 置入("name","A")后，其将会变为：
	{
		"data" : 3.14,
		"name" : "A"
	}
	*/
	方法 置入(键名 : 文本, 值 : 对象)
		@code
		try {
			#this.put(#键名, #值);
		} catch (JSONException e) {
			e.printStackTrace();
		}
		@end
	结束 方法

	/*
	移除TSON对象中指定键名对应的值
	{
		"data" : 3.14,
		"name" : "A"
	}
	这个TSON对象中有2个数据，调用 移除("name")后，其将会变为：
	{
		"data" : 3.14,
	}
	*/
	方法 移除(键名 : 文本)
		@code
		#this.remove(#键名);
		@end
	结束 方法

	/*
	判断TSON对象中是否存在指定键名
	*/
	方法 是否存在(键名 : 文本) : 逻辑型
		@code
		return #this.has(#键名);
		@end
	结束 方法

	/*
	将TSON对象转为文本
	*/
	方法 到文本(缩进空格数 : 整数 = 0) : 文本
		@code
		if (#缩进空格数 == 0) {
			return #this.toString();
		}
		try {
			return #this.toString(#缩进空格数);
		} catch (JSONException e) {
			e.printStackTrace();
			return null;
		}
		@end
	结束 方法

	/*
	将TSON对象写出到文件
	*/
	@附加权限(安卓权限.文件权限_写入)
	方法 写出到文件(文件路径 : 文本)
		变量 结果 = 到文本(3)
		写出文本文件(文件路径, 结果)
	结束 方法

	/*
	获取TSON对象中所有键名
	*/
	属性读 键名() 为 文本[]
		@code
        java.util.List<String> list = new java.util.ArrayList<>();
        java.util.Iterator<String> it = #this.keys();
		while (it.hasNext()) {
			list.add(it.next());
		}
        return list.toArray(new String[0]);
      @end
	结束 属性

	@code
	private final static String JSON_INIT_ERROR = "TSON数据文本错误";
	@end
结束 类

/*
TSON数组类，用于存储TSON数组内容
TSON数组是TSON对象值的一种数据格式，可以存储多个内容，如：
{
	"key",[1,2,3]
}
用[]包起来的就是TSON数组，其中有3个数据，也就是说key这个键所对应的数据是一个TSON数组，其中有3个数字
*/
@导入Java("org.json.*")
@指代类("org.json.JSONArray")
类 TSON数组
	/*
	通过传入TSON文本直接初始化TSON数组
	*/
	@运算符重载
	方法 =(TSON文本 : 文本)
		@code
		try {
			return new JSONArray(#TSON文本);
		} catch (Exception e) {
			throw new RuntimeException(JSON_INIT_ERROR);
		}
		@end
	结束 方法

	/*
	获取TSON数组中指定索引所对应的对象值，如：
	[1,"a"]
	其中索引为0处所对应的数据就是一个整数值，其是一个对象值，因为对象是所有类型的基础类
	索引为1处所对应的数据就是一文本数值，其也是一个对象值
	*/
	@运算符重载
	方法 [](索引 : 整数) : 对象
		返回 取对象(索引)
	结束 方法

	/*
	向TSON数组中置入新的值，可以为TSON对象，TSON数组，文本值，整数值等，如：
	[1,2]
	这个TSON数组中只有一个数据，调用 置入("name")后，其将会变为：
	[1,2,"name"]
	*/
	@运算符重载
	方法 []=(索引 : 整数, 值 : 对象)
		@code
		try {
			#this.put(#索引, #值);
		} catch (JSONException e) {
			e.printStackTrace();
		}
		@end
	结束 方法

	/*
	获取TSON数组中指定索引处所对应的子TSON对象，如：
	[
		"data" : {
			"name": "abc"
		},
		123
	]
	其中索引为0处所对应的数据就是一个TSON对象
	*/
	方法 取TSON对象(索引 : 整数) : TSON对象
		@code
		return #this.optJSONObject(#索引);
		@end
	结束 方法

	/*
	获取TSON数组中指定索引处所对应的TSON数组，如：
	[1,2,[1,2]]
	其中的索引为2处所对应的数据就是一个TSON数组
	*/
	方法 取TSON数组(索引 : 整数) : TSON数组
		@code
		return #this.optJSONArray(#索引);
		@end
	结束 方法

	/*
	获取TSON数组中指定索引处所对应的对象值，如：
	["abc",123]
	其中的索引为0处所对应的数据就是一个文本值，其是一个对象值，因为对象是所有类型的基础类
	索引为1所对应的数据就是一个整数值，其也是一个对象值
	*/
	方法 取对象(索引 : 整数) : 对象
		@code
		try {
			return #this.get(#索引);
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return null;
		@end
	结束 方法

	/*
	获取TSON数组中指定索引处所对应的文本值，如：
	["abc",123]
	索引为0所对应的数据就是一个文本值
	*/
	方法 取文本(索引 : 整数) : 文本
		@code
		return #this.optString(#索引);
		@end
	结束 方法

	/*
	获取TSON数组中指定索引处所对应的整数值，如：
	["abc",123]
	索引为1所对应的数据就是一个整数值
	*/
	方法 取整数(索引 : 整数) : 整数
		@code
		return #this.optInt(#索引);
		@end
	结束 方法

	/*
	获取TSON数组中指定索引处所对应的小数值，如：
	["abc",3.14]
	索引为1所对应的数据就是一个小数值
	*/
	方法 取小数(索引 : 整数) : 小数
		@code
		return #this.optDouble(#索引);
		@end
	结束 方法

	/*
	获取TSON数组中指定索引处所对应的逻辑型值，如：
	["abc",true]
	索引为1所对应的数据就是一个逻辑型值
	*/
	方法 取逻辑值(索引 : 整数) : 逻辑型
		@code
		return #this.optBoolean(#索引);
		@end
	结束 方法

	/*
	向TSON数组中置入新的值
	*/
	方法 置入(值 : 对象)
		@code
		#this.put(#值);
		@end
	结束 方法

	/*
	移除TSON数组中指定索引处成员
	*/
	方法 移除(索引 : 整数)
		@code
		#this.remove(#索引);
		@end
	结束 方法

	//按键值对匹配删除对应行，仅删除匹配的第一个
	方法 匹配移除(键名:文本, 值:文本) : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
			if(#this.optJSONObject(jid).getString(#键名) == #值) {
           	 #this.remove(jid);
				ispass = true;
				break;
			}
			jid++;
        	}
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法


	//按键值对匹配删除对应行，仅删除匹配的第一个
	方法 匹配移除2(键名:文本, 值:整数) : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
			if(#this.optJSONObject(jid).getInt(#键名) == #值) {
           	 #this.remove(jid);
				ispass = true;
				break;
			}
			jid++;
        	}
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法




	//按键值对匹配删除对应行，仅删除匹配的第一个
	方法 匹配移除3(键名:文本, 值:长整数) : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
			if(#this.optJSONObject(jid).getLong(#键名) == #值) {
           	 #this.remove(jid);
				ispass = true;
				break;
			}
			jid++;
        	}
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法



	//按键值对匹配删除对应行，仅删除匹配的第一个
	方法 匹配移除4(键名:文本, 值:小数) : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
			if(#this.optJSONObject(jid).getDouble(#键名) == #值) {
           	 #this.remove(jid);
				ispass = true;
				break;
			}
			jid++;
        	}
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法



	//按键值对匹配删除对应行，仅删除匹配的第一个
	方法 匹配移除5(键名:文本, 值:逻辑型) : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
			if(#this.optJSONObject(jid).getBoolean(#键名) == #值) {
           	 #this.remove(jid);
				ispass = true;
				break;
			}
			jid++;
        	}
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法




	//按键值对匹配删除对应行，删除所有匹配项
	方法 全部匹配移除(键名:文本, 值:文本) : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
			if(#this.optJSONObject(jid).getString(#键名) == #值) {
           	 #this.remove(jid);
				ispass = true;
			}
			jid++;
        	}
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法



	//按键值对匹配删除对应行，仅删除匹配的第一个
	方法 全部匹配移除2(键名:文本, 值:整数) : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
			if(#this.optJSONObject(jid).getInt(#键名) == #值) {
           	 #this.remove(jid);
				ispass = true;
			}
			jid++;
        	}
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法




	//按键值对匹配删除对应行，仅删除匹配的第一个
	方法 全部匹配移除3(键名:文本, 值:长整数) : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
			if(#this.optJSONObject(jid).getLong(#键名) == #值) {
           	 #this.remove(jid);
				ispass = true;
			}
			jid++;
        	}
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法



	//按键值对匹配删除对应行，仅删除匹配的第一个
	方法 全部匹配移除4(键名:文本, 值:小数) : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
			if(#this.optJSONObject(jid).getDouble(#键名) == #值) {
           	 #this.remove(jid);
				ispass = true;
			}
			jid++;
        	}
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法



	//按键值对匹配删除对应行，仅删除匹配的第一个
	方法 全部匹配移除5(键名:文本, 值:逻辑型) : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
			if(#this.optJSONObject(jid).getBoolean(#键名) == #值) {
           	 #this.remove(jid);
				ispass = true;
			}
			jid++;
        	}
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法






	方法 清空() : 逻辑型
		@code
		int jid = 0;
		boolean ispass = false;
		try {
			while (#this.length() > 0) {
        	    #this.remove(jid);
				ispass = true;
				jid++;
      	  }
			return ispass;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		@end
	结束 方法





	/*
	获取TSON数组长度(成员数量)
	*/
	属性读 长度() : 整数
		@code
		return #this.length();
		@end
	结束 属性

	/*
	将TSON数组转为文本
	*/
	方法 到文本(缩进空格数 : 整数 = 0) : 文本
		@code
		if (#缩进空格数 == 0) {
			return #this.toString();
		}
		try {
			return #this.toString(#缩进空格数);
		} catch (JSONException e) {
			e.printStackTrace();
			return null;
		}
		@end
	结束 方法

	/*
	将TSON数组写出到文件
	*/
	@附加权限(安卓权限.文件权限_写入)
	方法 写出到文件(文件路径 : 文本)
		变量 结果 = 到文本(3)
		写出文本文件(文件路径, 结果)
	结束 方法

	@code
	private final static String JSON_INIT_ERROR = "TSON数据文本错误";
	@end
结束 类